home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et3_0-a1.lha / et3 / src / Object.C < prev    next >
C/C++ Source or Header  |  1992-07-23  |  16KB  |  721 lines
  1. #ifdef __GNUG__
  2. #pragma implementation
  3. #endif
  4.  
  5. #include "Object.h"
  6.  
  7. #include "Class.h"
  8. #include "OrdColl.h"
  9. #include "IdDictionary.h"
  10. #include "ObjInt.h"
  11. #include "Error.h"
  12. #include "String.h"
  13. #include "Storage.h"
  14. #include "ProgEnv.h"
  15. #include "System.h"
  16. #include "ObjectTable.h"
  17. #include "AccessMem.h"
  18. #include "MemBuf.h"
  19. #include "CmdNo.h"
  20.   
  21. //---- observing ---------------------------------------------------------
  22.  
  23. static IdDictionary *Observer; 
  24. // dictionary associating a list of observers with an Object
  25.  
  26. static IdDictionary *DelayedChanges; 
  27. // dictionary to store the delayed Change messages, the key is the object pointer
  28. // (IdDictionary) the value is an OrderedCollection of ChangeMessages (see below).
  29. // The first entry of the OrderedCollection is a reference count of the number of
  30. // DelayChanges requests. FlushChanges will be executed when the count drops to 0.
  31. // Whether change messages are delayed is set with the cObjDelayChanges flag
  32.  
  33. ONEXIT(Object)
  34. {
  35.     if (Observer) {
  36.     Observer->FreeValues();
  37.     SafeDelete(Observer);
  38.     }
  39.     if (DelayedChanges) {
  40.     DelayedChanges->FreeAllValues();
  41.     SafeDelete(DelayedChanges);
  42.     }
  43. }
  44.  
  45. class ChangeMessage: public Object {
  46. public:
  47.     void *what;
  48.     int part, id;
  49. public:
  50.     MetaDef(ChangeMessage);
  51.     ChangeMessage(void *w, int p, int i)
  52.     { what= w; part= p; id= i; }
  53. };
  54.  
  55. NewMetaImpl(ChangeMessage,Object, (TX(what), T(part), T(id)));
  56.  
  57. extern u_long Storage_lastobj, Storage_lastobjend;
  58. extern bool Storage_proto;
  59.  
  60. //---- Object ------------------------------------------------------------------
  61.  
  62. int Object::_an;
  63. AccessMembers *Object::_accessMembers;
  64.  
  65. //---- automatically added by macro metaImpl -----------------------------------
  66.  
  67. Class *Object::isa;
  68.  
  69. static Class ObjectClassMetaImpl0("Object",
  70.                   sizeof (Object),
  71.                   new Object((_dummy*)0),
  72.                   __FILE__,
  73.                   "./Object.h",
  74.                   __LINE__,
  75.                   1,
  76.                   TRUE);
  77.  
  78. Object::Object(class _dummy*)
  79. {
  80.     Storage_proto= TRUE;
  81.     flags= cObjNonDeleted | cObjIsProto;
  82.     if ((u_long)this >= Storage_lastobj && (u_long)this < Storage_lastobjend)
  83.     SetFlag(cObjIsShared);
  84.     isa= &ObjectClassMetaImpl0;
  85.     ObjectClassMetaImpl0.SetSuper();
  86. }
  87.  
  88. Class *Object::IsA()
  89. {
  90.     return &ObjectClassMetaImpl0;
  91. }
  92.  
  93. void Object::Members(AccessMembers *ac)
  94. {
  95.     _accessMembers= ac;
  96.     ScanMembers(TX(flags), TP(Observer), TP(DelayedChanges), TP(isa));
  97. }
  98.  
  99. //---- ordinary methods ----------------------------------------------------
  100.  
  101. Object::Object(int f)
  102. {
  103.     flags= (f & cFlagMask) | cObjNonDeleted;
  104.     if ((u_long)this >= Storage_lastobj && (u_long)this < Storage_lastobjend) {
  105.     SetFlag(cObjIsShared);
  106.     if (Storage_proto)
  107.         flags|= cObjIsProto;
  108.     }
  109.     ObjectTable::Add(this);
  110. }
  111.  
  112. Object::~Object()
  113. {
  114.     if (! TestFlag(cObjNonDeleted))
  115.     Fatal("~Object", "object deleted twice");
  116.       
  117.     if (IsObserved()) {
  118.     Collection *observers= GetObservers(); // GetObservers is statically bound!!!
  119.     flags &= ~cObjIsObserved;
  120.     if (observers)
  121.         CleanupObservers(observers);
  122.     }
  123.     flags&= ~cObjNonDeleted;
  124.     ObjectTable::Remove(this);
  125. }
  126.  
  127. void Object::FreeAll()
  128. {
  129. }
  130.  
  131. //----- flag manipulation ------------------------------------------------------
  132.  
  133. void Object::SetFlag(int f, bool b)
  134. {
  135.     if (b)
  136.     SetFlag(f);
  137.     else
  138.     ResetFlag(f);
  139. }
  140.  
  141. //---- attributes --------------------------------------------------------------
  142.  
  143. char *Object::ClassName()
  144. {
  145.     return IsA()->Name();
  146. } 
  147.  
  148. //---- comparing ---------------------------------------------------------------
  149.  
  150. u_long Object::Hash () 
  151. {
  152.     return (u_long) this;
  153. }
  154.  
  155. bool Object::IsEqual(Object *anOp)
  156. {
  157.      return anOp == this;
  158. }
  159.  
  160. int Object::Compare(Object*)
  161. {
  162.     AbstractMethod ("Compare");
  163.     return 0;
  164. }
  165.  
  166. //---- converting, activation/passivation ------------------------------------
  167.  
  168. char* Object::AsString()
  169. {
  170.     return 0;
  171. }
  172.  
  173. static bool printOnWhenObserved(Object*, Object* op, Object *from)
  174. {
  175.     return op->PrintOnWhenObserving(from);
  176. }
  177.  
  178. OStream &Object::PrintOn(OStream &os)
  179. {
  180.     Collection *selectedDeps= 0;
  181.        
  182.     os.MakeIndex(this);
  183.     if (IsObserved()) {
  184.     Collection *observers= GetObservers();
  185.     if (observers->IsEmpty()) { // impossible ??
  186.         flags &= ~cObjIsObserved;
  187.         DestroyObserverColl();
  188.     } else {
  189.         selectedDeps= observers->Select((BoolFun)printOnWhenObserved, this);
  190.         if (selectedDeps->IsEmpty())
  191.         SafeDelete(selectedDeps);
  192.     }
  193.     }
  194.     os << (flags & cFlagMask) SP << selectedDeps SP;
  195.     SafeDelete(selectedDeps);
  196.     return os;
  197. }
  198.  
  199. OStream &operator<< (OStream &os, Object *op)
  200. {
  201.     int ix;
  202.  
  203.     if ((op == 0) || (op == op->IsA())) {       // a null pointer
  204.     os.put('0');                            // "0" seems to be portable!
  205.  
  206.     } else if ((ix= os.IndexOfPtr(op)) >= 0 ) { // already in table ?
  207.     os.put('@');
  208.     os << ix;                               // write index
  209.     
  210.     } else {
  211.     Object *op2;
  212.     // special case: we are copying inside a single address space
  213.     // try if class has overwritten deepclone
  214.     if (os.IsForDeepClone() && (op2= op->deepclone())) {
  215.         os.put('#');
  216.         os << os.MakeIndex(op) SP << (u_long) op2;
  217.     } else {
  218.         if (! op->IsKindOf(Class))
  219.         os.put('\n');                   // pretty printing
  220.         os.put('{');
  221.         os << os.MakeIndex(op) SP << op->IsA();
  222.         op->PrintOn(os);
  223.         os.put('}');
  224.     }
  225.     }
  226.     os.put(' ');
  227.     os.flush();
  228.     return os;
  229. }
  230.  
  231. IStream &Object::ReadFrom(IStream &is)
  232. {
  233.     int f;
  234.     Collection *observers;
  235.     
  236.     is.MakeIndex(this);
  237.     is >> f >> observers;
  238.     SetFlag(f);
  239.     if (observers) {
  240.     flags |= cObjIsObserved;
  241.     SetObserverColl(observers);
  242.     }
  243.     return is;
  244. }
  245.  
  246. Object *Object::ReadAndMap(IStream &is)
  247. {
  248.     Object *op= New();
  249.     (*op).ReadFrom(is);
  250.     return op;
  251. }
  252.  
  253. /* Read in new object, put a pointer to it in *op.
  254. *  Make sure object read in is cl or a descendant of cl.
  255. */
  256. IStream& LoadPtr(IStream &is, Object *&op, Class *expected)
  257. {
  258.     static char *cLoadError= "Object::LoadPtr";
  259.     Class *clp= 0;
  260.     char c= 0;
  261.     int ix= 0;
  262.     u_long ptr= 0;
  263.  
  264.     op= 0;
  265.  
  266.     is >> c;
  267.  
  268.     switch (c) {
  269.     
  270.     case '0':       // a nil pointer
  271.     return is;
  272.     
  273.     case '#':       // a real address from DeepCopy
  274.     is >> ix >> ptr;
  275.     if (is.IsForDeepClone()) {
  276.         op= (Object*) ptr;
  277.         is.AtPut(ix, op);
  278.     } else
  279.         Error(cLoadError, "shouldn't happen: got address %d", ptr);
  280.     break;
  281.  
  282.     case '@':       // table index of existing object
  283.     is >> ix;
  284.     op= is.At(ix);
  285.     if (op == (Object*) 0x01) {
  286.         Error(cLoadError, "object is 1", ix);
  287.         op= 0;
  288.     } else if (op == 0)
  289.         Error(cLoadError, "can't find element %d in instancetable", ix);
  290.     break;
  291.  
  292.     case '{':       // new object
  293.     is >> ix >> clp;
  294.     if (clp == 0)   // assume class "Class"
  295.         clp= Meta(Class);
  296.         
  297.     op= clp->Proto()->ReadAndMap(is);
  298.     is.AtPut(ix, op);
  299.  
  300.     int level= 1;
  301.     bool first= TRUE;
  302.     while (is.get(c)) {
  303.         if (c == '{') {
  304.         level++;
  305.         continue;
  306.         }
  307.         if (c == '}') {
  308.         level--;
  309.         if (level <= 0)
  310.             break;
  311.         continue;
  312.         }
  313.         if (!Isspace(c)) {
  314.         if (first) {
  315.             Error(cLoadError, "expected \'}\' at end of <%s>; got: (%02x)",
  316.                                 clp->Name(), c);
  317.             first= FALSE;
  318.         }
  319.         }
  320.     };
  321.     break;
  322.  
  323.     default:
  324.     Error(cLoadError, "unexpected character 0x%02x", c & 0xff);
  325.     break;
  326.     }
  327.     
  328.     if (op == 0) {
  329.     if (expected) {
  330.         Error(cLoadError, "can't read object; creating dummy instance of %s",
  331.                                 expected->Name());
  332.         op= expected->Proto()->New();
  333.     }
  334.     } else if (expected) {
  335.     Class *clp= op->IsA();
  336.     if (clp && !clp->isKindOf(expected))
  337.         Error(cLoadError, "trying to read a %s into a %s", clp->Name(),
  338.                                 expected->Name());
  339.     }
  340.  
  341.     return is;
  342. }
  343.  
  344. //---- cloning -----------------------------------------------------------------
  345.  
  346. Object *Object::New()
  347. {
  348.     Object *op= IsA()->Proto()->Object::Clone();
  349.     op->InitNew();
  350.     return op;
  351. }
  352.  
  353. void Object::InitNew()
  354. {
  355. }
  356.  
  357. Object *Object::Clone()
  358. {
  359.     Object *op= (Object*) Storage::ObjectAlloc(IsA()->Size());
  360.     // give the new object the correct vtable in a portable? way
  361.     memcpy(op, this, IsA()->Size());
  362.     op->flags |= cObjNonDeleted | cObjIsShared;
  363.     op->flags &= ~cObjIsProto;
  364.     ObjectTable::Add(op);
  365.     return op;
  366. }
  367.  
  368. Object *Object::deepclone()
  369. {
  370.     return 0;
  371. }
  372.  
  373. Object *Object::DeepClone()
  374. {
  375.     Object* op;
  376.     
  377.     if (op= deepclone())
  378.     return op;
  379.     
  380.     MemBuf mb;
  381.     OStream to(&mb);
  382.     IStream from(&mb);
  383.     
  384.     to.PrepareForDeepClone();
  385.     to << this;
  386.     to.flush();
  387.  
  388.     mb.SwitchToRead();
  389.     
  390.     from.PrepareForDeepClone();
  391.     from >> op;
  392.  
  393.     return op;
  394. }
  395.  
  396. //---- change propagation, object observing ------------------------------------
  397.  
  398. Collection *Object::MakeObserverColl()
  399. {
  400.     Collection *cp;
  401.     if (Observer == 0)
  402.     Observer= new IdDictionary(70);
  403.     if (cp= (Collection*) Observer->AtKey(this))
  404.     Warning("MakeObserverColl", "there are already Observers for %s", ClassName());
  405.     else {
  406.     cp= new OrdCollection;
  407.     Observer->PutAtKeyIfAbsent(cp, this);
  408.     }
  409.     return cp;
  410. }
  411.  
  412. Collection *Object::GetObservers()
  413. {
  414.     if (Observer == 0) {
  415.     Warning("GetObservers", "without SetObserver");
  416.     return 0;
  417.     }      
  418.     Collection *cp= (Collection*) Observer->AtKey(this);
  419.     if (cp == 0) 
  420.     Warning("GetObservers", "observers == 0 in GetObservers for %s", ClassName());
  421.     return cp;
  422. }
  423.  
  424. void Object::DestroyObserverColl()
  425. {
  426. #ifdef OLD
  427.     if (Observer) {
  428.     Assoc *ap= (Assoc*) Observer->RemoveKey(this);
  429.     if (ap) {
  430.         Object *observers= ap->Value();
  431.         if (observers) {
  432.         SafeDelete(observers);
  433.         } else
  434.         Warning ("DestroyObserverColl", "0 in DestroyObserverColl() for %s",
  435.                                 ClassName());
  436.         SafeDelete(ap);
  437.     }
  438.     } else
  439.     Warning("DestroyObserverColl", "Observer == 0");
  440. #endif
  441.  
  442.     if (Observer) {
  443.     Object *value;
  444.     if (Observer->RemoveKey(this, value)) { 
  445.         // could also check for IsObserved
  446.         if (value) {
  447.         SafeDelete(value);      // value is a container
  448.         } else
  449.         Warning("DestroyObserverColl", "0 in DestroyObserverColl() for %s",
  450.             ClassName());
  451.     }
  452.     } else
  453.     Warning("DestroyObserverColl", "Observer == 0");
  454. }
  455.  
  456. void Object::SetObserverColl(Collection *cp)
  457. {
  458.     DestroyObserverColl();
  459.     if (Observer == 0)
  460.     Observer= new IdDictionary(70);
  461.     Observer->PutAtKeyIfAbsent(cp, this);
  462. }
  463.  
  464. void Object::CleanupObservers(Collection *observers)
  465. {
  466.     observers->ForEach(Object,DoObserve)(cIdNone, cPartSenderDied, 0, this);
  467.     DestroyObserverColl();
  468. }
  469.  
  470. void Object::AddObserver(Object* op)
  471. {
  472.     Collection *observer;
  473.     
  474.     if (op) {
  475.     if (!IsObserved() || ((observer= GetObservers()) == 0)) {
  476.         flags |= cObjIsObserved; 
  477.         observer= MakeObserverColl();
  478.     } else {
  479.         if (observer->FindPtr(op)) {
  480.         Warning("AddObserver", "duplicate in observers");
  481.         return;
  482.         }
  483.     }
  484.     observer->Add(op);
  485.     }
  486. }
  487.  
  488. Object* Object::RemoveObserver(Object* op)
  489. {
  490.     if (this && IsObserved()) {
  491.     Collection *observers= GetObservers();
  492.     if (observers) {
  493.         if (op) 
  494.         op= observers->RemovePtr(op);
  495.         if (observers->IsEmpty()) {
  496.         flags &= ~cObjIsObserved;
  497.         DestroyObserverColl();
  498.         }
  499.         return op;
  500.     }
  501.     }
  502.     return 0;
  503. }
  504.  
  505. void Object::Send(int id, int part, void *vp)
  506. {
  507.     if (!IsObserved())
  508.     return;
  509.  
  510.     if (TestFlag(cObjDelayChanges)) {
  511.     if (DelayedChanges) {
  512.         Collection *col= (Collection*) DelayedChanges->AtKey(this);
  513.         if (col == 0) {
  514.         Warning("Send", "No collection for change messages, %s", ClassName());
  515.         col= new OrdCollection;
  516.         DelayedChanges->PutAtKeyIfAbsent(col, this);
  517.         }
  518.         col->Add(new ChangeMessage(vp, part, id));
  519.     } else
  520.         Error("Send", "DelayedChanges still 0");
  521.     } else {
  522.     Collection *observers= GetObservers();
  523.     if (observers)
  524.         observers->ForEach(Object,DoObserve)(id, part, vp, this);
  525.     }
  526. }
  527.  
  528. void Object::DoObserve(int, int, void*, Object*)
  529. {
  530. }
  531.  
  532. class Iterator *Object::GetObserverIter()        
  533. {
  534.     if (!IsObserved())
  535.     return 0;
  536.     Collection *observers= GetObservers(); 
  537.     if (observers)
  538.     return observers->MakeIterator();
  539.     return 0;
  540. }
  541.  
  542. void Object::DelayChanges()
  543. {
  544.     SeqCollection *col= 0;
  545.     
  546.     flags |= cObjDelayChanges;
  547.     if (DelayedChanges == 0)
  548.     DelayedChanges= new IdDictionary;
  549.     else
  550.     col= (SeqCollection*) DelayedChanges->AtKey(this);
  551.     if (col) {
  552.     ObjInt *ref= (ObjInt*) col->At(0);
  553.     ++(*ref);
  554.     } else {
  555.     col= new OrdCollection;
  556.     col->Add(new ObjInt(0));
  557.     DelayedChanges->PutAtKeyIfAbsent(col, this);
  558.     }
  559. }
  560.  
  561. void Object::FlushChanges()
  562. {
  563.     if (DelayedChanges) {
  564.     SeqCollection *col= (SeqCollection*) DelayedChanges->AtKey(this);
  565.     if (col) {
  566.         ObjInt *ref= (ObjInt*)col->At(0);
  567.         if (ref->GetValue() <= 0) {
  568.         flags &= ~cObjDelayChanges;
  569.         ChangeMessage *cm;
  570.         Iter next(col);
  571.         next(); // overread reference count
  572.         while (cm= (ChangeMessage*) next()) 
  573.             Send(cm->id, cm->part, cm->what);
  574.         DelayedChanges->RemoveKey(this);
  575.         col->FreeAll();
  576.         SafeDelete(col);
  577.         } else 
  578.         (*ref)--;
  579.     }
  580.     }
  581. }
  582.  
  583. bool Object::PrintOnWhenObserving(Object*)
  584. {
  585.     return TRUE;    
  586. }
  587.  
  588. //---- error handling ----------------------------------------------------------
  589.  
  590. void Object::DoError(int level, char *location, char *fmt, va_list va)
  591. {
  592.     ::ErrorHandler(level, form("%s::%s", ClassName(), location), fmt, va);
  593. }
  594.  
  595. void Object::Error(char *location, char *va_(fmt), ...)
  596. {
  597.     va_list ap;
  598.     va_start(ap, va_(fmt));
  599.     DoError(cError, location, va_(fmt), ap);
  600.     va_end(ap);
  601. }
  602.  
  603. void Object::SysError(char *location,  char *va_(fmt), ...)
  604. {
  605.     va_list ap;
  606.     va_start(ap, va_(fmt));
  607.     DoError(cSysError, location, va_(fmt), ap);
  608.     va_end(ap);
  609. }
  610.  
  611. void Object::Warning(char *location, char *va_(fmt), ...)
  612. {
  613.     va_list ap;
  614.     va_start(ap, va_(fmt));
  615.     DoError(cWarning, location, va_(fmt), ap);
  616.     va_end(ap);
  617. }
  618.  
  619. void Object::Fatal(char *location, char *va_(fmt), ...)
  620. {
  621.     va_list ap;
  622.     va_start(ap, va_(fmt));
  623.     DoError(cFatal, location, va_(fmt), ap);
  624.     va_end(ap);
  625. }
  626.  
  627. //---- fire walls --------------------------------------------------------------
  628.  
  629. void Object::AbstractMethod(char *method)
  630. {
  631.     Warning(method, "abstract method called"); 
  632. }
  633.  
  634. void Object::MayNotUse(char *method)
  635. {
  636.     Warning(method, "not allowed to use this method");
  637. }
  638.  
  639. Object *Object::guard(Class *should)
  640. {
  641.     if (this && IsA()->isKindOf(should))
  642.     return this;
  643.     if (this)
  644.     Error("Guard", "object is not a %s but a %s", should->Name(), ClassName());
  645.     return 0;
  646. }
  647.  
  648. //---- inspecting, debugging ---------------------------------------------------
  649.  
  650. void Object::Inspect(bool block)
  651. {
  652.     gProgEnv->InspectObject(this, block);
  653. }
  654.  
  655. void Object::EditSource(bool definition)
  656. {
  657.     gProgEnv->EditSourceOf(IsA(), definition);
  658. }
  659.  
  660. void Object::InspectorId(char *buf, int bufSize)
  661. {
  662.     char *name= AsString();
  663.     if (name)
  664.     strn0cpy(buf, name, bufSize);
  665. }
  666.  
  667. void Object::CollectParts(class Collection *)
  668. {
  669. }
  670.  
  671. void Object::ScanMembers(u_long va_(firstTag), ...)
  672. {
  673.     int n= _an;
  674.     _an= 0;
  675.     va_list ap;
  676.     va_start(ap, va_(firstTag));
  677.     if (_accessMembers)
  678.     _accessMembers->ScanMembers(this, (int)va_(firstTag), ap, n);
  679.     va_end(ap);
  680. }
  681.  
  682. //---- interface for accessing instance variables by name will be improved
  683. //     in a future release
  684.  
  685.     class FindMember: public AccessMembers {
  686.     public:
  687.     const char *lookfor;
  688.     int offset, len, type;
  689.     Object *op;
  690.     Class *classp;
  691.         
  692.     FindMember(Object *in, const char *name)
  693.         { offset= -1; op= in; lookfor= name; type= 0; len= -1;}
  694.     void Member(char *name, int offset, int lenOrOffset, int type,
  695.                             Class*, bool g, bool lg);
  696.     };
  697.     
  698.     void FindMember::Member(char *name, int o, int, int t, Class *c, bool ,
  699.                                     bool)
  700.     {
  701.     if (strcmp(name, lookfor) == 0) {
  702.         offset= o;
  703.         type= t;
  704.         classp= c;
  705.         // if (l == -1)
  706.         // len= GetLength(op, o, l, t, c, g, lg);
  707.     }
  708.     }
  709.     
  710. void *Object::GetAddrOf(const char *name, Class *&cl)
  711. {
  712.     FindMember m(this, name);
  713.     IsA()->EnumerateMembers(&m);
  714.     if (m.offset != -1) {
  715.     cl= m.classp;
  716.     return (void*) ((u_long) this + (u_long) m.offset);
  717.     }
  718.     return 0;
  719. }
  720.  
  721.